/* 
 * Autores:
 *      Jonathan Lopez  11106
 *      Jorge Martínez  11237
 * 
 * Archivo: 
 * Última Revision: $Rev: 64 $
 *      Fecha: $Date: 2011-09-18 02:32:49 +0000 (Sun, 18 Sep 2011) $
 */ 

package Manejo.Transporte.Registros;

import java.util.HashMap;
import java.util.ArrayList;

import Manejo.Transporte.Contenedor;
import Archivador.*;

/**
 * Registro de todos los contenedores que existen en el programa
 * 
 * @author Jonathan López
 * @author Jorge Martinez
 */
public class RegContenedores
{
    private HashMap<ID, Contenedor> contenedores;
    private final String nombreRegistro = "RegistroContenedores";

    /**
     * Construye el registro de Contenedores
     */
    public RegContenedores()
    {
        contenedores = new HashMap<ID, Contenedor>();
    }
    
    /**
     * Lee los Contenedores desde la base de datos
     */
    public void inicializar( Registros registros )
    {
        // Leer los Contenedores de la base de datos
        String[] infoContenedores = Archivador.leerRegistro(nombreRegistro);
        if( infoContenedores != null ){
            for( String linea: infoContenedores ){
                if( !linea.equals("") && !leerContenedor( linea, registros ) )
                    System.out.println("*ERROR RegContenedores* - No se pudo leer Contenedor");
            }
        }
    }
    
    /**
     * Guarda el registro de Contenedores
     */
    public void guardarTodo(){
        // Serializa todos los Contenedores
        ArrayList<String> lineaContenedores = new ArrayList<String>();
        
        for( ID idContenedor: contenedores.keySet() ){
            String srIdContenedor = "[" + idContenedor.guardar() + "]";
            String srContenedor = contenedores.get( idContenedor ).guardar();
            String linea = srIdContenedor + iArchivable.separadorObjetos + srContenedor;
            lineaContenedores.add(linea);
        }
        
        // Guarda el registro
        if( lineaContenedores.isEmpty() )
            lineaContenedores.add("");
        
        Archivador.guardarRegistro(nombreRegistro,
                lineaContenedores.toArray( new String[0] ));
    }
    
    
    /**
     * Agrega un nuevo Contenedor al registro y le asigna un ID
     * @param nuevoContenedor Contenedor a agregar
     * @return nuevo ID del Contenedor
     */
    public ID agregarContenedor( Contenedor nuevoContenedor )
    {
        ID nuevoID = GeneradorID.nuevoID();
        while( contenedores.containsKey( nuevoID ) ){
            // Muy improbable
            // TODO: notificar al log por cada uno de estos casos
            nuevoID = GeneradorID.nuevoID();
        }
        
        contenedores.put( nuevoID, nuevoContenedor );
        return nuevoID;
    }
    
    /**
     * Regresa el Contenedor asociada con el ID dado
     * @param idContenedor ID del Contenedor a buscar
     * @return Contenedor asociado al ID o null si no se encuentra
     */
    public Contenedor obtenerContenedor( ID idContenedor )
    {
        return contenedores.get( idContenedor );
    }
    
    /**
     * Regresa un arreglo con todos los Contenedors contenidos en el registro
     * @return Contenedor[] con todos los Contenedores en el registro
     */
    public Contenedor[] obtenerTodosContenedores()
    {
        return contenedores.values().toArray( new Contenedor[0] );
    }
    
    /**
     * Regresa el ID de un Contenedor
     * @param contenedorObjetivo 
     * @return ID del Contenedor
     */
    public ID obtenerID( Contenedor contenedorObjetivo )
    {
        for( ID id: contenedores.keySet() ){
            if( contenedores.get(id).equals( contenedorObjetivo) )
                return id;
        }
        
        return ID.idNulo;
    }
    
    /**
     * Elimina un Contenedor del registro según su ID
     * @param idContenedor ID del Contenedor a eliminar
     * @return el Contenedor asociada al ID dado, o null si no existía
     */
    public Contenedor eliminarContenedor( ID idContenedor )
    {
        return contenedores.remove( idContenedor );
    }
    
    /**
     * Lee un solo Contenedor a partir de una línea del registro
     * @param linea
     * @return 
     */
    private boolean leerContenedor( String linea, Registros registros )
    {
        String[] partes = linea.split( iArchivable.separadorObjetos, 2 );
        if( partes.length != 2 )
            return false;
        
        // Interpreta el ID del Contenedor
        String srID = partes[0];
        ID idContenedor = ID.parseID( Util.eliminarExtremos(srID) );
        if( idContenedor.equals( ID.idNulo ) )
            return false;
        
        // Interpreta el Contenedor
        Contenedor contenedorActual = Contenedor.parseContenedor( partes[1],
                registros );
        if( contenedorActual == null )
            return false;
        
        // Agrega el nuevo Contenedor
        contenedores.put( idContenedor, contenedorActual );
        return true;
    }
}
